Preserve iOS terminal shell while reconnecting - #6647

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+TerminalReplay.swift (3)

8-11: 📐 Maintainability & Code Quality | 🟠 Major

🧩 Analysis chain

🏁 Script executed:

cat -n Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+TerminalReplay.swift

Repository: manaflow-ai/cmux

Length of output: 6623

---

Address replay task join stale-client issue and logger isolation.

This file has three issues:

1. Logger must be nonisolated (line 8): File-scoped Logger should be nonisolated private let to avoid unnecessary MainActor coupling in Swift 6.

2. Stale-client replay join bug (lines 20–25): When remoteClient changes while a replay task is in-flight, a new caller joins the stale task (created with the old client). The task's request uses the captured old client, the stale-client guard at line 67 fails, and both callers incorrectly receive false. The new caller should receive a fresh replay on the current client. Fix: include client identity in the task dedup key, or check client freshness before joining.

3. Error logging privacy leak (line 109): Error details are logged as .public, exposing potentially sensitive information (network failures, auth errors, paths). Use .private instead.

Logger fix

-private let mobileShellReplayLog = Logger(
+nonisolated private let mobileShellReplayLog = Logger(
     subsystem: Bundle.main.bundleIdentifier ?? "dev.cmux.ios",
     category: "mobile-shell"
 )

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

nonisolated private let mobileShellReplayLog = Logger(
    subsystem: Bundle.main.bundleIdentifier ?? "dev.cmux.ios",
    category: "mobile-shell"
)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite`+TerminalReplay.swift
around lines 8 - 11, Add the nonisolated keyword to the mobileShellReplayLog
Logger declaration to mark it as nonisolated private let and avoid unnecessary
MainActor coupling in Swift 6. For the stale-client replay join bug in the
replay task logic around lines 20-25, modify the task dedup key to include the
client identity (such as remoteClient's reference or identity) so that when
remoteClient changes, a new caller receives a fresh replay task instead of
joining a stale task created with the old client. Finally, locate the error
logging statement around line 109 and change the privacy level from .public to
.private to prevent sensitive error details from being exposed in logs.

Source: Coding guidelines

---

20-49: 🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

Don’t join replay tasks created for a stale remote client.

Line 20 joins any in-flight replay for the surface before checking whether it was created for the current remoteClient. If the connection changes while an old replay is pending, the new replay request joins the old task; that task then fails the remoteClient === client guard on Line 67 and no replay is started for the new connection. Track the client/generation in the replay slot and only join when it matches the current connection.

As per path instructions, terminal replay/recovery/liveness must use one authoritative structured source of truth and fail closed when the reliable signal is stale.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite`+TerminalReplay.swift
around lines 20 - 49, The issue is that the code joins an in-flight replay task
without verifying it was created for the current remoteClient, causing stale
tasks to be reused when the connection changes. Modify the
terminalReplayRetryTasksBySurfaceID storage to track both the replay task and
the client it was created for (consider creating a structure to hold both
values). In the early return check for existingTask, compare the stored client
against the current remoteClient before joining; only join if they match,
otherwise proceed to create a new task for the current connection. Update the
cleanup section to clear the stored client alongside the task.

Source: Path instructions

---

109-109: 🔒 Security & Privacy | 🟠 Major | ⚡ Quick win

Redact replay errors in production logs.

String(describing: error) can include transport/auth details; logging it as .public risks exposing tokens or private endpoints. Keep the failure visible but mark the interpolated error private.

Proposed fix

-            mobileShellReplayLog.error("CMUX_REPLAY failed surface=\(surfaceID, privacy: .public) error=\(String(describing: error), privacy: .public)")
+            mobileShellReplayLog.error("CMUX_REPLAY failed surface=\(surfaceID, privacy: .public) error=\(String(describing: error), privacy: .private)")

As per coding guidelines, logs must not expose secrets, tokens, customer content, or personal data without explicit private redaction.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite`+TerminalReplay.swift
at line 109, In the mobileShellReplayLog.error call within the CMUX_REPLAY error
logging statement, the interpolated error description is currently marked with
privacy: .public, which risks exposing sensitive information like tokens or
private endpoints. Change the privacy parameter for the String(describing:
error) interpolation from .public to .private, while keeping the surfaceID
privacy setting as .public, to ensure error details are properly redacted in
production logs.

Source: Coding guidelines

Packages/iOS/CmuxMobileShell/Tests/CmuxMobileShellTests/MobileShellTerminalReplayTests.swift (1)

92-93: 🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

Remove fixed Task.sleep readiness waits from these tests.

Line 92 and Line 142 use wall-clock sleeps to gate assertions. This makes the tests timing-sensitive and flaky; switch to causality/predicate waits using existing signals (pollUntil, router counters, collector output).

As per coding guidelines, “Tests must not introduce fixed sleep/Task.sleep calls used to wait for async readiness before an assertion.”

Suggested change

-    try await Task.sleep(nanoseconds: 50_000_000)
-    `#expect`(await router.count(of: "mobile.terminal.replay") == 1)
+    let noDuplicateReplayRequest = try await pollUntil {
+        await router.count(of: "mobile.terminal.replay") == 1
+    }
+    `#expect`(noDuplicateReplayRequest)
@@
-    await router.releaseHeldReplayRequest(number: 1)
-    try await Task.sleep(nanoseconds: 100_000_000)
-    `#expect`(store.terminalReplayRetryTaskIDsBySurfaceID["live-terminal"] == newerTaskID)
+    await router.releaseHeldReplayRequest(number: 1)
+    let orphanedCompletionDidNotClobberNewerTask = try await pollUntil {
+        collector.lines.contains { $0.contains("ORPHANED-REPLAY") } &&
+        store.terminalReplayRetryTaskIDsBySurfaceID["live-terminal"] == newerTaskID
+    }
+    `#expect`(orphanedCompletionDidNotClobberNewerTask)

Also applies to: 141-143

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileShell/Tests/CmuxMobileShellTests/MobileShellTerminalReplayTests.swift`
around lines 92 - 93, Remove the fixed Task.sleep call on line 92 and the
similar one on lines 141-143 from the test methods. Instead of sleeping for a
fixed duration before asserting, use predicate-based waits with existing signals
such as pollUntil, router counter checks, or collector output to wait for the
actual condition to be true. Replace the sleep-then-assert pattern with a
mechanism that polls the router counter (or other available signal) until it
reaches the expected value, ensuring the test waits for the actual readiness
condition rather than wall-clock time.

Source: Coding guidelines

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/CMUXMobileRootView.swift (1)

189-229: 🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Use one authoritative root-routing source instead of duplicating branch policy in-view.

This branch chain re-implements correctness-critical destination logic that already exists in MobileRootAuthGate.rootContentDestination(...). Keeping both paths live risks drift (wrong root destination in reconnect/auth edge states).

Suggested refactor

 `@ViewBuilder`
 private var rootContent: some View {
-    if shouldShowTerminalLayoutPreview {
-        terminalLayoutPreview
-    } else if shouldShowWorkspaceListLayoutPreview {
-        workspaceListLayoutPreview
-    } else if !isAuthenticated {
-        SignInView()
-    } else if store.shouldPreserveWorkspaceShellDuringReconnect {
-        WorkspaceShellView(store: store, signOut: signOut, showAddDevice: showAddDevice)
-    } else if store.connectionState != .connected && shouldShowRestoringStoredMac {
-        RestoringStoredMacWorkspaceShell(...)
-    } else if shouldShowOnboarding {
-        onboardingFlow
-    } else if store.connectionState != .connected && !store.hasKnownPairedMac {
-        DisconnectedWorkspaceShellView(...)
-    } else {
-        WorkspaceShellView(store: store, signOut: signOut, showAddDevice: showAddDevice)
-    }
+    switch MobileRootAuthGate.rootContentDestination(
+        showsTerminalLayoutPreview: shouldShowTerminalLayoutPreview,
+        showsWorkspaceListLayoutPreview: shouldShowWorkspaceListLayoutPreview,
+        showsRestoringSession: false,
+        authenticated: isAuthenticated,
+        preservesWorkspaceShellDuringReconnect: store.shouldPreserveWorkspaceShellDuringReconnect,
+        connectionState: store.connectionState,
+        showsRestoringStoredMac: shouldShowRestoringStoredMac,
+        hasKnownPairedMac: store.hasKnownPairedMac,
+        isReconnectingStoredMac: store.isReconnectingStoredMac,
+        showsOnboarding: shouldShowOnboarding
+    ) {
+    // map enum cases to views
+    }
 }

As per path instructions, apply reliability-single-source-of-truth.md: correctness-critical routing should use one authoritative structured source.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/CMUXMobileRootView.swift`
around lines 189 - 229, The if-else branch chain in CMUXMobileRootView is
duplicating the routing logic that already exists in
MobileRootAuthGate.rootContentDestination(...), creating a risk of divergence in
authentication and connection state handling. Replace this entire branch chain
with a call to the authoritative MobileRootAuthGate.rootContentDestination(...)
method to establish a single source of truth for root content routing decisions,
ensuring consistent behavior across all reconnection, authentication, and
onboarding edge cases.

Source: Path instructions

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MobileConnectionRecoveryBanner.swift (1)

38-45: 📐 Maintainability & Code Quality | 🔴 Critical

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

XCSTRINGS="Resources/Localizable.xcstrings"
keys=(
  "mobile.recovery.lost"
  "mobile.recovery.lostDescription"
  "mobile.recovery.reconnecting"
  "mobile.recovery.switchAccount"
  "mobile.recovery.retry"
)

echo "Checking key presence..."
for k in "${keys[@]}"; do
  jq -e --arg k "$k" '.strings[$k]' "$XCSTRINGS" >/dev/null \
    && echo "OK: $k" \
    || echo "MISSING: $k"
done

echo
echo "Checking locale coverage (expect at least: en, ja)..."
for k in "${keys[@]}"; do
  echo "== $k =="
  jq -r --arg k "$k" '.strings[$k].localizations | keys[]?' "$XCSTRINGS" | sort
done

Repository: manaflow-ai/cmux

Length of output: 519

---

Add missing localization keys to Resources/Localizable.xcstrings with translations for all supported locales.

The code references localization keys (mobile.recovery.lost, mobile.recovery.lostDescription, mobile.recovery.reconnecting, mobile.recovery.switchAccount, mobile.recovery.retry) that do not exist in the string catalog. While defaultValue provides an English fallback at runtime, the keys must be registered in Resources/Localizable.xcstrings with translated entries for every supported locale (English and Japanese) to satisfy the localization requirement.

Also applies to: 51-54, 109, 189, 212

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/MobileConnectionRecoveryBanner.swift`
around lines 38 - 45, The L10n.string calls in
MobileConnectionRecoveryBanner.swift reference localization keys
(mobile.recovery.lost, mobile.recovery.lostDescription,
mobile.recovery.reconnecting, mobile.recovery.switchAccount,
mobile.recovery.retry) that are not registered in the string catalog. Add these
missing keys to Resources/Localizable.xcstrings with proper translations for all
supported locales (English and Japanese). Use the defaultValue strings from each
L10n.string call as the English translation, and provide corresponding Japanese
translations for each key to satisfy the localization requirement.

Sources: Coding guidelines, Path instructions

Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/WorkspaceListView.swift (1)

181-187: 📐 Maintainability & Code Quality | 🟠 Major

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

XCSTRINGS="Resources/Localizable.xcstrings"
keys=(
  "mobile.loading.timeout.title"
  "mobile.loading.timeout.message"
)

for k in "${keys[@]}"; do
  echo "== $k =="
  jq -e --arg k "$k" '.strings[$k]' "$XCSTRINGS" >/dev/null \
    && echo "present" || echo "MISSING"
  echo "locales:"
  jq -r --arg k "$k" '.strings[$k].localizations | keys[]?' "$XCSTRINGS" | sort
  echo
done

Repository: manaflow-ai/cmux

Length of output: 285

---

Add localization keys for timeout messages to the string catalog.

The code routes through L10n.string() but the keys mobile.loading.timeout.title and mobile.loading.timeout.message are missing from Resources/Localizable.xcstrings. Add entries for both keys with translations in all supported locales (English and Japanese).

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileShellUI/Sources/CmuxMobileShellUI/WorkspaceListView.swift`
around lines 181 - 187, Add the missing localization keys to the
Resources/Localizable.xcstrings file. Create entries for both
mobile.loading.timeout.title and mobile.loading.timeout.message that are
currently referenced in the WorkspaceListView but not defined in the string
catalog. For each key, provide translations in all supported locales including
English (using the defaultValue strings already present in the code) and
Japanese.

Sources: Coding guidelines, Path instructions

Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceRegistry.swift (1)

108-116: 🩺 Stability & Availability | 🟠 Major

🧩 Analysis chain

🏁 Script executed:

# First, let's check the file and understand the context
ast-grep outline Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceRegistry.swift

Repository: manaflow-ai/cmux

Length of output: 513

---

🏁 Script executed:

# Read the specific section with more context
sed -n '95,130p' Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceRegistry.swift

Repository: manaflow-ai/cmux

Length of output: 1378

---

🏁 Script executed:

# Get the full function/method context
sed -n '80,150p' Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceRegistry.swift

Repository: manaflow-ai/cmux

Length of output: 2345

---

Use a cancellation-aware timeout mechanism instead of DispatchQueue.asyncAfter and fire-and-forget Task blocks.

Lines 108-116 use DispatchQueue.global(qos: .userInitiated).asyncAfter with a 1-second timeout and two separate fire-and-forget Task blocks to resume the continuation. This pattern violates two Swift runtime guidelines:

1. Timing-based repair path: asyncAfter introduces an unowned, untrackable delay in production code to paper over a potential executor hang.
2. Fire-and-forget Tasks with meaningful lifecycle: Both the executor callback (lines 108–110) and the timeout task (lines 113–115) can independently call continuationBox.resume(), creating a race where both fires and crashes with "tried to resume an already-resumed continuation."

Replace this with a cancellation-aware timeout that is tied to the request lifecycle. Use withTaskGroup or Task.withDeadline to ensure the timeout cancels the executor task once text is retrieved, or re-architect the executor callback to guarantee a single completion path without a separate timeout fallback. Document why the executor might not complete if a defensive timeout is genuinely unavoidable.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceRegistry.swift`
around lines 108 - 116, The current implementation uses DispatchQueue.asyncAfter
with fire-and-forget Task blocks which creates a race condition where both the
executor callback and the timeout task can independently call
continuationBox.resume(), causing a crash. Replace this pattern with a
cancellation-aware timeout mechanism using withTaskGroup or Task.withDeadline
that ties the timeout to the request lifecycle and ensures only one completion
path can fire. If a defensive timeout is genuinely necessary, restructure the
executor callback to guarantee a single completion path (either from the
executor itself or the timeout, but not both) and document why the executor
might not complete on its own.

Sources: Coding guidelines, Path instructions

Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceView.swift (1)

2210-2216: 🩺 Stability & Availability | 🟠 Major

🧩 Analysis chain

🌐 Web query:

cmux iOS support status shipped product 2024 2025

💡 Result:

As of June 2026, official iOS support for the cmux terminal multiplexer has been in active development and integration throughout 2025 and 2026, transitioning from third-party companion prototypes to a first-party Swift-based mobile terminal [1][2]. Key status updates include: First-Party iOS Integration (2025-2026): The official cmux project (manaflow-ai/cmux) has been actively developing a native Swift iOS/iPadOS terminal client [1][2]. This implementation uses a custom CMUXMobileCore for protocol handling, Network.framework for TCP transport, and Ghostty-based rendering [1][2]. Recent 2026 updates have focused on stabilizing mobile RPC, authentication flows, and onboarding guidance [1][3]. Transport and Connectivity: The official iOS client has historically relied on Tailscale for secure, remote connectivity between the iOS device and a Mac host [4][3]. As of mid-2026, there is an active transition to adopt the iroh protocol (QUIC-based) as the default transport for iOS-to-Mac communication, with Tailscale being relegated to an optional, opt-in fallback [5]. Third-Party Companions (2024-2025): Prior to and alongside official efforts, the ecosystem saw third-party companion apps emerge to bridge the gap [6][7]. Projects such as cmux-mobile and cmux-companion provided functionality like terminal monitoring, remote control, and workspace management, often requiring a separate bridge binary running on the host Mac to translate local Unix socket APIs into network-accessible streams [6][7]. In summary, while community-driven companion apps provided early mobile access during 2024 and 2025, the project transitioned to a native, first-party iOS terminal experience in 2026, integrating directly with the core application architecture [1][2].

Citations:

• 1: #4055
• 2: #5079
• 3: #5714
• 4: #5722
• 5: #5735
• 6: https://github.com/richardhowes/cmux-mobile
• 7: https://github.com/itsmaleen/cmux-companion

---

Replace sleep-based output timeout with state-driven recovery signaling.

iOS is a shipped product as of 2026. This path uses ContinuousClock().sleep(for:) to implement output-apply timeout in production runtime code, which violates .github/review-bot-rules/swift-blocking-runtime.md. Timing-based waits (Task.sleep, delayed dispatch, polling-style waits) in shipped app/runtime code must be replaced with state-driven recovery signaling, real timer abstractions, cancellation-aware schedulers, or explicit state transitions. A simple sleep-based timeout leaves the caller and state machine unaware of when recovery completes and can block or delay output delivery.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceView.swift`
around lines 2210 - 2216, The sleep-based timeout implemented with
ContinuousClock().sleep(for:) in the timeoutTask violates production runtime
code standards for shipped apps. Replace the timing-based wait mechanism that
uses duration calculated from Self.outputApplyTimeoutSeconds with state-driven
recovery signaling by implementing either a real timer abstraction, a
cancellation-aware scheduler, or explicit state transitions. This ensures that
the caller and state machine remain aware of when recovery completes and
prevents the sleep from blocking or delaying output delivery.

Sources: Coding guidelines, Path instructions

Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceView+ReplayRecovery.swift (1)

37-44: 🩺 Stability & Availability | 🟠 Major

🧩 Analysis chain

🏁 Script executed:

cat -n Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceView+ReplayRecovery.swift | head -60

Repository: manaflow-ai/cmux

Length of output: 3370

---

🏁 Script executed:

# Check if there are other recovery timeout patterns or Timer usage in the file
rg -n "timeout|Timer|sleep|asyncAfter" Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceView+ReplayRecovery.swift -A 2 -B 2

Repository: manaflow-ai/cmux

Length of output: 749

---

🏁 Script executed:

# Check the Recovery Timeout constant and understand the intended behavior
rg -n "recoveryReplayApplyTimeoutSeconds" Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/ -B 3 -A 3

Repository: manaflow-ai/cmux

Length of output: 2247

---

Remove DispatchQueue.asyncAfter from recovery replay timeout; use a cancellation-aware timer abstraction.

Line 39 uses DispatchQueue.global(qos: .userInitiated).asyncAfter to implement a 2-second replay apply timeout. This violates the policy against delayed-dispatch delays in shipped app code. Even with structured state checks and explicit fail-over logic, async timing in recovery/repair paths must use a proper cancellation-aware timer abstraction, async sequence, or state-driven event rather than DispatchQueue.asyncAfter or Task.sleep.

Per .github/review-bot-rules/swift-blocking-runtime.md, "Flag DispatchQueue.asyncAfter, timers, or polling loops in shipped app/runtime Swift code as failures by default, even for small delays" and "Retry backoff, keepalive loops, readiness waits, delayed dispatch, and polling require a real cancellation-aware scheduler, timer abstraction, async sequence, callback, notification, or state transition."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileTerminal/Sources/CmuxMobileTerminal/GhosttySurfaceView`+ReplayRecovery.swift
around lines 37 - 44, The recoveryReplayTask is implementing a 2-second timeout
using DispatchQueue.global(qos: .userInitiated).asyncAfter with a checked
continuation, which violates the policy against delayed-dispatch patterns in
shipped app code. Replace this approach with a cancellation-aware timer
abstraction, async sequence, or state-driven event. Remove the
DispatchQueue.asyncAfter call and the continuation.resume() inside the async
block, then refactor the timeout mechanism to use an appropriate
cancellation-aware timer implementation that respects Task cancellation
semantics.

Sources: Coding guidelines, Path instructions

Packages/iOS/CmuxMobileTerminalKit/Tests/CmuxMobileTerminalKitTests/TerminalSurfaceOutputWaitStateTests.swift (1)

34-35: 🩺 Stability & Availability | 🟡 Minor | ⚡ Quick win

Avoid order-dependent assertion for cancellation results.

cancelAll().map(\.id) can be nondeterministic when backed by unordered storage, which risks flaky CI. Compare as a set (or sort before asserting).

Suggested fix

-    `#expect`(waits.cancelAll().map(\.id) == [first, second])
+    `#expect`(Set(waits.cancelAll().map(\.id)) == Set([first, second]))

As per coding guidelines, "Tests must not assert an ordered result of an unordered Set / Dictionary (or equivalent); sort or compare as sets instead."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@Packages/iOS/CmuxMobileTerminalKit/Tests/CmuxMobileTerminalKitTests/TerminalSurfaceOutputWaitStateTests.swift`
around lines 34 - 35, The assertion on `cancelAll().map(\.id)` compares the
result as an ordered array, which is nondeterministic when cancelAll is backed
by unordered storage like a Set or Dictionary. Change the assertion to compare
the results as sets instead of relying on order by converting both sides to sets
(or sorting both sides before comparison) to ensure the test is deterministic
and does not fail randomly in CI.

Source: Coding guidelines